home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / langs / iconv8_l.arc / IDOL.ARC / IDOLBOOT.ICN < prev    next >
Encoding:
Text File  |  1990-03-19  |  31.6 KB  |  992 lines
  1. global fin,fout,fName,fLine,alpha,alphadot,white,nonwhite,nonalpha
  2. global classes,comp,exec,strict,links,imports,loud,compiles
  3. procedure initialize()
  4. #line 47 "idol.iol"
  5.   loud     := 1
  6.   comp     := 0
  7.   alpha    := &ucase ++ &lcase ++ '_' ++ &digits
  8.   nonalpha := &cset -- alpha
  9.   alphadot := alpha ++ '.'
  10.   white    := ' \t\014'
  11.   nonwhite := &cset -- white
  12.   classes  := taque()
  13.   links    := []
  14.   imports  := []
  15.   compiles := []
  16.   sysinitialize()
  17. end
  18. procedure main(args)
  19. #line 62 "idol.iol"
  20.     initialize()
  21.     if *args = 0 then write("usage: idol files...")
  22.     else {
  23.       every i := 1 to *args do {
  24.     if \exec then next
  25.     if args[i][1] == "-" then {
  26.       case map(args[i]) of {
  27.         "-c"   : {
  28.         sysok := &null
  29.         if comp = 0 then comp := -1
  30.         }
  31.         "-install": return install(args[1:i+1])
  32.         "-quiet"  : loud := &null
  33.         "-strict" : strict := 1
  34.         "-s"      : sysok := &null
  35.         "-t"      : comp := -2
  36.         "-version": return write("Idol version 6.30 of 3/14/90") & 0
  37.         "-x"      : exec := i
  38.       }
  39.         }
  40.         else if args[i][find(".cl",args[i]):0] := "" then push(imports,args[i])
  41.     else if args[i][find(".icn",args[i]):0] := "" then {
  42.       push(links,args[i])
  43.       icont(" -c "||args[i])
  44.     }
  45.     else if args[i][find(".u1",args[i]):0] := "" then push(links,args[i])
  46.     else if (args[i][find(".iol",args[i]):0] := "") |
  47.         tryopen(args[i]||".iol","r") then {
  48.       /exe := i
  49.       args[i][find(".iol",args[i]):0] := ""
  50.       /fout := sysopen(args[i]||".icn","w")
  51.       readinput(args[i]||".iol",1)
  52.         } else {
  53.  
  54.  
  55.  
  56.       if tryopen(args[i]||".icn","r") then {
  57.         push(links,args[i])
  58.         icont(" -c "||args[i])
  59.       }
  60.       else if tryopen(args[i]||".u1") then push(links,args[i])
  61.       else if tryenvopen(args[i]) then push(imports,args[i])
  62.     }
  63.       }
  64.       gencode()
  65.       close(\fout)
  66.       if comp = 1 then makeexe(args,exe)
  67.     }
  68. end
  69. procedure gencode()
  70. #line 118 "idol.iol"
  71.   if \loud then write("Class import/export:")
  72.  
  73.  
  74.  
  75.   every cl := (__self1 := classes).__methods.foreach_t(__self1.__state) do (__self2 := cl).__methods.writespec(__self2.__state)
  76.  
  77.  
  78.  
  79.   repeat {
  80.     added := 0
  81.     every super:= ((__self2 := ((__self1 := classes).__methods.foreach_t(__self1.__state))).__methods.foreachsuper(__self2.__state) | !imports) do{
  82.       if /(__self1 := classes).__methods.lookup(__self1.__state,super) then {
  83.     added := 1
  84.     fname := filename(super)
  85.     readinput(envpath(fname),2)
  86.     if /(__self1 := classes).__methods.lookup(__self1.__state,super) then halt("can't import class '",super,"'")
  87.     writesublink(fname)
  88.       }
  89.     }
  90.     if added = 0 then break
  91.   }
  92.  
  93.  
  94.  
  95.   every (__self2 := ((__self1 := classes).__methods.foreach_t(__self1.__state))).__methods.transitive_closure(__self2.__state)
  96.  
  97.  
  98.  
  99.   if \loud then write("Generating code:")
  100.   writesublink("i_object")
  101.   every s := !links do writelink(s)
  102.   write(fout)
  103.   every out := (__self1 := classes).__methods.foreach(__self1.__state) do { 
  104.     name := filename((__self1 := out).__methods.name(__self1.__state))
  105.     (__self1 := out).__methods.write(__self1.__state)
  106.     put(compiles,name)
  107.     writesublink(name)
  108.   }
  109.   if *compiles>0 then cdicont(compiles)
  110. end
  111. procedure notquote(s)
  112. #line 713 "idol.iol"
  113.   quotes := 0
  114.   outs := ""
  115.  
  116.   s ? {
  117.     while outs ||:= tab(find("\\")+1) do { move(1) }
  118.     outs ||:= tab(0)
  119.   }
  120.   s := outs
  121.   outs := ""
  122.   s ? {
  123.     while outs ||:= tab(find("\""|"'")+1) do {
  124.     quotes +:= 1
  125.     if tab(find(outs[-1])) then {
  126.         quotes +:= 1
  127.         move(1)
  128.     }
  129.     }
  130.   }
  131.   if quotes % 2 = 0 then return
  132. end
  133. procedure readln()
  134. #line 739 "idol.iol"
  135.     count := 0
  136.     if line := read(fin) then {
  137.     fLine +:= 1
  138.     line[ 1(x<-find("#",line),notquote(line[1:x])) : 0] := ""
  139.     line := trim(line)
  140.     while ((x := find("$",line)) & notquote(line[1:x])) do {
  141.         z := line[x+1:0] ||" "    
  142.         if find(line[x+1],"!*@?") then {
  143.         z ? {
  144.             move(1)
  145.             tab(many(white))
  146.             if not (id := tab(many(alphadot))) then {
  147.               if not match("(") then halt("readline can't parse ",line)
  148.               if not (id := tab(&pos<bal())) then
  149.               halt("readline: cant bal ",&subject)
  150.             }
  151.             case line[x+1] of {
  152.             "@": Op := "activate"
  153.             "*": Op := "size"
  154.             "!": Op := "foreach"
  155.             "?": Op := "random"
  156.             default: halt("readline: unknown operator $",line[x+1])
  157.             }
  158.             count +:= 1
  159.             line[x:0] :=
  160.             "(__self"||count||" := "||id||").__methods."||
  161.             Op||"(__self"||count||".__state)"||tab(0)
  162.         }
  163.         } else {
  164.         reverse(line[1:x])||" " ? {
  165.             tab(many(white))
  166.             if not (id := reverse(tab(many(alphadot)))) then {
  167.               if not match(")") then halt("readline: can't parse")
  168.               if not (id := reverse(tab(&pos<bal(&cset,')','('))))
  169.             then halt("readline: can't bal ",&subject)
  170.             }
  171.             nummatched := &pos-1
  172.         }
  173.         if not (lp := find("(",z)) then halt("readline: expected '('")
  174.         if z[lp+1] ~== ")" then c:="," else c:=""
  175.         count +:= 1
  176.         line[x-nummatched : x+lp+1] :=
  177.           "(__self"||count||" := "||id||").__methods."||
  178.             z[1:lp+1]||"__self"||count||".__state"||c
  179.         }
  180.     }
  181.     return line
  182.  
  183.  
  184.     } else fail
  185. end
  186. procedure readinput(name,phase)
  187. #line 795 "idol.iol"
  188.     if \loud then write("\t",name)
  189.     fName := name
  190.     fLine := 0
  191.     fin   := sysopen(name,"r")
  192.     while line := readln() do {
  193.     line ? {
  194.         tab(many(white))
  195.         if ="class" then {
  196.         decl := class()
  197.         (__self1 := decl).__methods.read(__self1.__state,line,phase)
  198.         if phase=1 then {
  199.             (__self1 := decl).__methods.writemethods(__self1.__state)
  200.             (__self1 := classes).__methods.insert(__self1.__state,decl,(__self2 := decl).__methods.name(__self2.__state))
  201.         } else (__self1 := classes).__methods.insert_t(__self1.__state,decl,(__self2 := decl).__methods.name(__self2.__state))
  202.         }
  203.         else if ="procedure" then {
  204.         if comp = 0 then comp := 1
  205.         decl := method("")
  206.         (__self1 := decl).__methods.read(__self1.__state,line,phase)
  207.         (__self1 := decl).__methods.write(__self1.__state,fout,"")
  208.         }
  209.         else if ="record" then {
  210.         if comp = 0 then comp := 1
  211.         decl := declaration(line)
  212.         (__self1 := decl).__methods.write(__self1.__state,fout,"")
  213.         }
  214.         else if ="global" then {
  215.         if comp = 0 then comp := 1
  216.         decl := Global(line)
  217.         (__self1 := decl).__methods.write(__self1.__state,fout,"")
  218.         }
  219.         else if ="method" then {
  220.         halt("readinput: method outside class")
  221.         }
  222.     }
  223.     }
  224.     close(fin)
  225. end
  226. procedure halt(args[])
  227. #line 838 "idol.iol"
  228.   errsrc()
  229.   every writes(&errout,!args)
  230.   stop()
  231. end
  232. procedure warn(args[])
  233. #line 844 "idol.iol"
  234.   errsrc()
  235.   every writes(&errout,!args)
  236.   write(&errout)
  237. end
  238. procedure errsrc()
  239. #line 850 "idol.iol"
  240.   writes(&errout,"\"",\fName,"\", line ",\fLine,": Idol/")
  241. end
  242. procedure tryopen(file,mode)
  243. #line 856 "idol.iol"
  244.   if f := open(file,mode) then return close(f)
  245. end
  246. procedure tryenvopen(file,mode)
  247. #line 859 "idol.iol"
  248.   return tryopen(envpath(file),mode)
  249. end
  250. procedure sysopen(file,mode)
  251. #line 862 "idol.iol"
  252.   if not (f := open(file,mode)) then
  253.       halt("Couldn't open file ",file," for mode ",mode)
  254.   return f
  255. end
  256. procedure envopen(file,mode)
  257. #line 867 "idol.iol"
  258.   return sysopen(envpath(file),mode)
  259. end
  260. procedure writelink(s)
  261. #line 870 "idol.iol"
  262.   write(fout,"link \"",s,"\"")
  263. end
  264. procedure icont(argstr,prefix)
  265. #line 873 "idol.iol"
  266. static s
  267. initial { s := (getenv("ICONT")|"icont") }
  268.   return mysystem(\prefix||s||argstr | s||argstr)
  269. end
  270. record idol_object(__state,__methods)
  271.  
  272. procedure declarationread(self,decl)
  273. #line 169 "idol.iol"
  274.     decl ? {
  275.  
  276.       tab(many(white))
  277.       if not (self.tag := =("procedure"|"class"|"method"|"record")) then
  278.     halt("declaration/read can't parse decl ",decl)
  279.       tab(many(white))
  280.  
  281.       if not (self.name := tab(many(alpha))) then
  282.     halt("declaration/read can't parse decl ",decl)
  283.  
  284.       if not tab(find("(")+1) then
  285.       halt("declaration/read can't parse decl ",decl)
  286.       tab(many(white))
  287.       self.fields := classFields()
  288.       if not ((__self1 := self.fields).__methods.parse(__self1.__state,tab(find(")")))) then
  289.     halt("declaration/read can't parse decl ",decl)
  290.     }
  291.   end
  292. procedure declarationwrite(self,f)
  293. #line 192 "idol.iol"
  294.      write(f,(__self1 := self).__methods.String(__self1.__state))
  295.   end
  296. procedure declarationString(self)
  297. #line 198 "idol.iol"
  298.     return self.tag || " " || self.name || "(" || (__self1 := self.fields).__methods.String(__self1.__state) || ")"
  299.   end
  300. record declaration_state(__state,__methods,name,fields,tag)
  301. record declaration_methods(read,write,String,name)
  302. global declaration__oprec
  303. procedure declaration(name,fields,tag)
  304. local self,clone
  305. initial {
  306.   if /declaration__oprec then declarationinitialize()
  307.   }
  308.   self := declaration_state(&null,declaration__oprec,name,fields,tag)
  309.   self.__state := self
  310.   declarationinitially(self)
  311.   return idol_object(self,declaration__oprec)
  312. end
  313.  
  314. procedure declarationinitialize()
  315.   initial declaration__oprec := declaration_methods(declarationread,declarationwrite,declarationString,declarationname)
  316. end
  317. procedure declarationinitially(self)
  318. #line 201 "idol.iol"
  319.   if \self.name then (__self1 := self).__methods.read(__self1.__state,self.name)
  320. end
  321. procedure declarationname(self)
  322.   return .(self.name)
  323. end
  324.  
  325. procedure bodyread(self)
  326. #line 210 "idol.iol"
  327.     self.fn    := fName
  328.     self.ln    := fLine
  329.     self.text  := []
  330.     while line := readln() do {
  331.       put(self.text, line)
  332.       line ? { tab(many(white)); if ="end" & &pos > *line then return }
  333.     }
  334.     halt("body/read: eof inside a procedure/method definition")
  335.   end
  336. procedure bodywrite(self,f)
  337. #line 220 "idol.iol"
  338.     if \self.ln then write(f,"#line ",self.ln," \"",self.fn,"\"")
  339.     every write(f,(__self1 := self).__methods.foreach(__self1.__state)) 
  340.   end
  341. procedure bodydelete(self)
  342. #line 224 "idol.iol"
  343.     return pull(self.text)
  344.   end
  345. procedure bodysize(self)
  346. #line 227 "idol.iol"
  347.     return (*\ (self.text)) | 0
  348.   end
  349. procedure bodyforeach(self)
  350. #line 230 "idol.iol"
  351.     if t := \self.text then suspend !self.text
  352.   end
  353. record body_state(__state,__methods,fn,ln,text)
  354. record body_methods(read,write,delete,size,foreach)
  355. global body__oprec
  356. procedure body(fn,ln,text)
  357. local self,clone
  358. initial {
  359.   if /body__oprec then bodyinitialize()
  360.   }
  361.   self := body_state(&null,body__oprec,fn,ln,text)
  362.   self.__state := self
  363.   return idol_object(self,body__oprec)
  364. end
  365.  
  366. procedure bodyinitialize()
  367.   initial body__oprec := body_methods(bodyread,bodywrite,bodydelete,bodysize,bodyforeach)
  368. end
  369. procedure classread(self,line,phase)
  370. #line 242 "idol.iol"
  371.     (__self1 := self).__methods.declaration.read(__self1.__state,line)
  372.     self.supers := idTaque(":")
  373.     (__self1 := self.supers).__methods.parse(__self1.__state,line[find(":",line)+1:find("(",line)] | "")
  374.     self.methods:= taque()
  375.     self.text   := body()
  376.     while line  := readln() do {
  377.       line ? {
  378.     tab(many(white))
  379.     if ="initially" then {
  380.         (__self1 := self.text).__methods.read(__self1.__state)
  381.         if phase=2 then return
  382.         (__self1 := self.text).__methods.delete(__self1.__state)    
  383.                 
  384.         return
  385.     } else if ="method" then {
  386.         decl := method(self.name)
  387.         (__self1 := decl).__methods.read(__self1.__state,line,phase)
  388.         (__self1 := self.methods).__methods.insert(__self1.__state,decl,(__self2 := decl).__methods.name(__self2.__state))
  389.     } else if ="end" then {
  390.     
  391.         return
  392.     } else if ="procedure" then {
  393.         decl := Procedure("")
  394.         (__self1 := decl).__methods.read(__self1.__state,line,phase)
  395.         /self.glob := []
  396.         put(self.glob,decl)
  397.     } else if ="global" then {
  398.         /self.glob := []
  399.         put(self.glob,Global(line))
  400.     } else if ="record" then {
  401.         /self.glob := []
  402.         put(self.glob,declaration(line))
  403.     } else if upto(nonwhite) then {
  404.         halt("class/read expected declaration on: ",line)
  405.     }
  406.       }
  407.     }
  408.     halt("class/read syntax error: eof inside a class definition")
  409.   end
  410. procedure classhas_initially(self)
  411. #line 286 "idol.iol"
  412.     return (__self1 := self.text).__methods.size(__self1.__state) > 0 
  413.   end
  414. procedure classispublic(self,fieldname)
  415. #line 289 "idol.iol"
  416.     if (__self1 := self.fields).__methods.ispublic(__self1.__state,fieldname) then return fieldname
  417.   end
  418. procedure classforeachmethod(self)
  419. #line 292 "idol.iol"
  420.     suspend (__self1 := self.methods).__methods.foreach(__self1.__state) 
  421.   end
  422. procedure classforeachsuper(self)
  423. #line 295 "idol.iol"
  424.     suspend (__self1 := self.supers).__methods.foreach(__self1.__state) 
  425.   end
  426. procedure classforeachfield(self)
  427. #line 298 "idol.iol"
  428.     suspend (__self1 := self.fields).__methods.foreach(__self1.__state) 
  429.   end
  430. procedure classtransitive_closure(self)
  431. #line 301 "idol.iol"
  432.     count := (__self1 := self.supers).__methods.size(__self1.__state) 
  433.     while count > 0 do {
  434.     added := taque()
  435.     every sc := (__self1 := self.supers).__methods.foreach(__self1.__state) do { 
  436.       if /(super := (__self1 := classes).__methods.lookup(__self1.__state,sc)) then
  437.         halt("class/transitive_closure: couldn't find superclass ",sc)
  438.       every supersuper := (__self1 := super).__methods.foreachsuper(__self1.__state) do {
  439.         if / (__self1 := self.supers).__methods.lookup(__self1.__state,supersuper) &
  440.          /(__self1 := added).__methods.lookup(__self1.__state,supersuper) then {
  441.           (__self1 := added).__methods.insert(__self1.__state,supersuper)
  442.         }
  443.       }
  444.     }
  445.     count := (__self1 := added).__methods.size(__self1.__state) 
  446.     every (__self1 := self.supers).__methods.insert(__self1.__state,(__self2 := added).__methods.foreach(__self2.__state)) 
  447.     }
  448.   end
  449. procedure classwritedecl(self,f,s)
  450. #line 323 "idol.iol"
  451.     writes(f, s," ",self.name)
  452.     if s=="class" & ( *(supers := (__self1 := self.supers).__methods.String(__self1.__state)) > 0 ) then
  453.         writes(f," : ",supers)
  454.     writes(f,"(")
  455.     rv := (__self1 := self.fields).__methods.String(__self1.__state,s)
  456.     if *rv > 0 then rv ||:= ","
  457.     if s~=="class" & \self.ifields then        
  458.       every l := !self.ifields do rv ||:= l.ident || ","
  459.     writes(f,rv[1:-1])
  460.     write(f,,")")
  461.   end
  462. procedure classwritespec(self,f)
  463. #line 335 "idol.iol"
  464.     f := envopen(filename(self.name),"w")
  465.     (__self1 := self).__methods.writedecl(__self1.__state,f,"class")
  466.     every (__self2 := ((__self1 := self.methods).__methods.foreach(__self1.__state))).__methods.writedecl(__self2.__state,f,"method") 
  467.     if (__self1 := self).__methods.has_initially(__self1.__state) then write(f,"initially")
  468.     write(f,"end")
  469.     close(f)
  470.   end
  471. procedure classwritemethods(self)
  472. #line 348 "idol.iol"
  473.     f:= envopen(filename(self.name)||".icn","w")
  474.     every (__self2 := ((__self1 := self.methods).__methods.foreach(__self1.__state))).__methods.write(__self2.__state,f,self.name) 
  475.  
  476.     if \self.glob & *self.glob>0 then {
  477.     write(f,"#\n# globals declared within the class\n#")
  478.     every i := 1 to *self.glob do (__self1 := (self.glob[i])).__methods.write(__self1.__state,f,"")
  479.     }
  480.     close(f)
  481.   end
  482. procedure classwrite(self)
  483. #line 362 "idol.iol"
  484.     f:= envopen(filename(self.name)||".icn","a")
  485.  
  486.  
  487.  
  488.     if /self.ifields then (__self1 := self).__methods.resolve(__self1.__state)
  489.  
  490.  
  491.  
  492.  
  493.     writes(f,"record ",self.name,"_state(__state,__methods")
  494.     rv := ","
  495.     rv ||:= (__self1 := self.fields).__methods.idTaque.String(__self1.__state)        
  496.     if rv[-1] ~== "," then rv ||:= ","
  497.     every s := (!self.ifields).ident do rv ||:= s || ","
  498.     write(f,rv[1:-1],")")
  499.  
  500.  
  501.  
  502.  
  503.     writes(f,"record ",self.name,"_methods(")
  504.     rv := ""
  505.  
  506.     every s := (((__self2 := ((__self1 := self.methods).__methods.foreach(__self1.__state))).__methods.name(__self2.__state))    |     
  507.         (__self1 := self.fields).__methods.foreachpublic(__self1.__state)    |    
  508.         (!self.imethods).ident        |    
  509.         (__self1 := self.supers).__methods.foreach(__self1.__state))                 
  510.     do rv ||:= s || ","
  511.  
  512.     if *rv>0 then rv[-1] := ""            
  513.     write(f,rv,")")
  514.  
  515.  
  516.  
  517.  
  518.  
  519.     writes(f,"global ",self.name,"__oprec")
  520.     every writes(f,", ", (__self1 := self.supers).__methods.foreach(__self1.__state),"__oprec") 
  521.     write(f)
  522.  
  523.  
  524.  
  525.  
  526.  
  527.     (__self1 := self).__methods.writedecl(__self1.__state,f,"procedure")
  528.     write(f,"local self,clone")
  529.  
  530.  
  531.  
  532.  
  533.     write(f,"initial {\n",
  534.         "  if /",self.name,"__oprec then ",self.name,"initialize()")
  535.     if (__self1 := self.supers).__methods.size(__self1.__state) > 0 then 
  536.     every (super <- (__self1 := self.supers).__methods.foreach(__self1.__state)) ~== self.name do 
  537.         write(f,"  if /",super,"__oprec then ",super,"initialize()\n",
  538.             "  ",self.name,"__oprec.",super," := ", super,"__oprec")
  539.     write(f,"  }")
  540.  
  541.  
  542.  
  543.  
  544.     writes(f,"  self := ",self.name,"_state(&null,",self.name,"__oprec")
  545.     every writes(f,",",(__self1 := self.fields).__methods.foreach(__self1.__state)) 
  546.     if \self.ifields then every writes(f,",",(!self.ifields).ident)
  547.     write(f,")\n  self.__state := self")
  548.  
  549.  
  550.  
  551.  
  552.     if (__self1 := self.text).__methods.size(__self1.__state) > 0 then write(f,"  ",self.name,"initially(self)") 
  553.  
  554.  
  555.  
  556.  
  557.     if (__self1 := self.supers).__methods.size(__self1.__state) > 0 then { 
  558.     every (super <- (__self1 := self.supers).__methods.foreach(__self1.__state)) ~== self.name do { 
  559.         if (__self2 := ((__self1 := classes).__methods.lookup(__self1.__state,super))).__methods.has_initially(__self2.__state) then {
  560.         if /madeclone := 1 then {
  561.             write(f,"  clone := ",self.name,"_state()\n",
  562.             "  clone.__state := clone\n",
  563.             "  clone.__methods := ",self.name,"__oprec")
  564.         }
  565.         write(f,"  # inherited initialization from class ",super)
  566.         write(f,"    every i := 2 to *self do clone[i] := self[i]\n",
  567.             "    ",super,"initially(clone)")
  568.         every l := !self.ifields do {
  569.             if l.class == super then
  570.             write(f,"    self.",l.ident," := clone.",l.ident)
  571.         }
  572.         }
  573.     }
  574.     }
  575.  
  576.  
  577.  
  578.  
  579.  
  580.  
  581.     write(f,"  return idol_object(self,",self.name,"__oprec)\n",
  582.         "end\n")
  583.  
  584.  
  585.  
  586.  
  587.     write(f,"procedure ",self.name,"initialize()")
  588.     writes(f,"  initial ",self.name,"__oprec := ",self.name,"_methods")
  589.     rv := "("
  590.     every s := (__self2 := ((__self1 := self.methods).__methods.foreach(__self1.__state))).__methods.name(__self2.__state) do {         
  591.       if *rv>1 then rv ||:= ","
  592.       rv ||:= self.name||s
  593.     }
  594.     every me := (__self1 := self.fields).__methods.foreachpublic(__self1.__state) do {    
  595.       if *rv>1 then rv ||:= ","            
  596.       rv ||:= self.name||me
  597.     }
  598.     every l := !self.imethods do {            
  599.       if *rv>1 then rv ||:= ","
  600.       rv ||:= l.class||l.ident
  601.     }
  602.     write(f,rv,")\n","end")
  603.  
  604.  
  605.  
  606.     if (__self1 := self).__methods.has_initially(__self1.__state) then {
  607.     write(f,"procedure ",self.name,"initially(self)")
  608.     (__self1 := self.text).__methods.write(__self1.__state,f)
  609.     write(f,"end")
  610.     }
  611.  
  612.  
  613.  
  614.  
  615.     every me := (__self1 := self.fields).__methods.foreachpublic(__self1.__state) do {
  616.       write(f,"procedure ",self.name,me,"(self)")
  617.       if \strict then {
  618.     write(f,"  if type(self.",me,") == ",
  619.         "(\"list\"|\"table\"|\"set\"|\"record\") then\n",
  620.         "    runerr(501,\"idol: scalar type expected\")")
  621.     }
  622.       write(f,"  return .(self.",me,")")
  623.       write(f,"end")
  624.       write(f)
  625.     }
  626.  
  627.     close(f)
  628.  
  629.   end
  630. procedure classresolve(self)
  631. #line 513 "idol.iol"
  632.  
  633.  
  634.  
  635.     self.imethods := []
  636.     self.ifields := []
  637.     ipublics := []
  638.     addedfields := table()
  639.     addedmethods := table()
  640.     every sc := (__self1 := self.supers).__methods.foreach(__self1.__state) do { 
  641.     if /(superclass := (__self1 := classes).__methods.lookup(__self1.__state,sc)) then
  642.         halt("class/resolve: couldn't find superclass ",sc)
  643.     every superclassfield := (__self1 := superclass).__methods.foreachfield(__self1.__state) do {
  644.         if /(__self1 := self.fields).__methods.lookup(__self1.__state,superclassfield) &
  645.            /addedfields[superclassfield] then {
  646.         addedfields[superclassfield] := superclassfield
  647.         put ( self.ifields , classident(sc,superclassfield) )
  648.         if (__self1 := superclass).__methods.ispublic(__self1.__state,superclassfield) then
  649.             put( ipublics, classident(sc,superclassfield) )
  650.         } else if \strict then {
  651.         warn("class/resolve: '",sc,"' field '",superclassfield,
  652.              "' is redeclared in subclass ",self.name)
  653.         }
  654.     }
  655.     every superclassmethod := (__self2 := ((__self1 := superclass).__methods.foreachmethod(__self1.__state))).__methods.name(__self2.__state) do {
  656.         if /(__self1 := self.methods).__methods.lookup(__self1.__state,superclassmethod) &
  657.            /addedmethods[superclassmethod] then {
  658.         addedmethods[superclassmethod] := superclassmethod
  659.         put ( self.imethods, classident(sc,superclassmethod) )
  660.         }
  661.     }
  662.     every public := (!ipublics) do {
  663.         if public.class == sc then
  664.         put (self.imethods, classident(sc,public.ident))
  665.     }
  666.     }
  667.   end
  668. #
  669. # globals declared within the class
  670. #
  671. record classident(class,ident)
  672. record class_state(__state,__methods,supers,methods,text,imethods,ifields,glob,name,fields,tag)
  673. record class_methods(read,has_initially,ispublic,foreachmethod,foreachsuper,foreachfield,transitive_closure,writedecl,writespec,writemethods,write,resolve,String,name,declaration)
  674. global class__oprec, declaration__oprec
  675. procedure class(supers,methods,text,imethods,ifields,glob,name,fields,tag)
  676. local self,clone
  677. initial {
  678.   if /class__oprec then classinitialize()
  679.   if /declaration__oprec then declarationinitialize()
  680.   class__oprec.declaration := declaration__oprec
  681.   }
  682.   self := class_state(&null,class__oprec,supers,methods,text,imethods,ifields,glob,name,fields,tag)
  683.   self.__state := self
  684.   clone := class_state()
  685.   clone.__state := clone
  686.   clone.__methods := class__oprec
  687.   # inherited initialization from class declaration
  688.     every i := 2 to *self do clone[i] := self[i]
  689.     declarationinitially(clone)
  690.     self.name := clone.name
  691.     self.fields := clone.fields
  692.     self.tag := clone.tag
  693.   return idol_object(self,class__oprec)
  694. end
  695.  
  696. procedure classinitialize()
  697.   initial class__oprec := class_methods(classread,classhas_initially,classispublic,classforeachmethod,classforeachsuper,classforeachfield,classtransitive_closure,classwritedecl,classwritespec,classwritemethods,classwrite,classresolve,declarationString,declarationname)
  698. end
  699. procedure methodread(self,line,phase)
  700. #line 556 "idol.iol"
  701.     (__self1 := self).__methods.declaration.read(__self1.__state,line)
  702.     self.text := body()
  703.     if phase = 1 then
  704.       (__self1 := self.text).__methods.read(__self1.__state)
  705.   end
  706. procedure methodwritedecl(self,f,s)
  707. #line 562 "idol.iol"
  708.     decl := (__self1 := self).__methods.String(__self1.__state)
  709.     if s == "method" then decl[1:upto(white,decl)] := "method"
  710.     else {
  711.     decl[1:upto(white,decl)] := "procedure"
  712.     decl[upto(white,decl)] ||:= self.class
  713.     if *self.class ~= 0 then {
  714.         i := find("(",decl)
  715.         decl[i] ||:= "self" || (((decl[i+1] ~== ")"), ",") | "")
  716.     }
  717.     }
  718.     write(f,decl)
  719.   end
  720. procedure methodwrite(self,f)
  721. #line 575 "idol.iol"
  722.     if self.name ~== "initially" then
  723.     (__self1 := self).__methods.writedecl(__self1.__state,f,"procedure")
  724.     (__self1 := self.text).__methods.write(__self1.__state,f)
  725.     self.text := &null            
  726.   end
  727. record method_state(__state,__methods,class,text,name,fields,tag)
  728. record method_methods(read,writedecl,write,String,name,declaration)
  729. global method__oprec, declaration__oprec
  730. procedure method(class,text,name,fields,tag)
  731. local self,clone
  732. initial {
  733.   if /method__oprec then methodinitialize()
  734.   if /declaration__oprec then declarationinitialize()
  735.   method__oprec.declaration := declaration__oprec
  736.   }
  737.   self := method_state(&null,method__oprec,class,text,name,fields,tag)
  738.   self.__state := self
  739.   clone := method_state()
  740.   clone.__state := clone
  741.   clone.__methods := method__oprec
  742.   # inherited initialization from class declaration
  743.     every i := 2 to *self do clone[i] := self[i]
  744.     declarationinitially(clone)
  745.     self.name := clone.name
  746.     self.fields := clone.fields
  747.     self.tag := clone.tag
  748.   return idol_object(self,method__oprec)
  749. end
  750.  
  751. procedure methodinitialize()
  752.   initial method__oprec := method_methods(methodread,methodwritedecl,methodwrite,declarationString,declarationname)
  753. end
  754. procedure Globalwrite(self,f)
  755. #line 587 "idol.iol"
  756.     write(f,self.s)
  757.   end
  758. record Global_state(__state,__methods,s)
  759. record Global_methods(write)
  760. global Global__oprec
  761. procedure Global(s)
  762. local self,clone
  763. initial {
  764.   if /Global__oprec then Globalinitialize()
  765.   }
  766.   self := Global_state(&null,Global__oprec,s)
  767.   self.__state := self
  768.   return idol_object(self,Global__oprec)
  769. end
  770.  
  771. procedure Globalinitialize()
  772.   initial Global__oprec := Global_methods(Globalwrite)
  773. end
  774. procedure Tablesize(self)
  775. #line 596 "idol.iol"
  776.     return (* \ self.t) | 0
  777.   end
  778. procedure Tableinsert(self,x,key)
  779. #line 599 "idol.iol"
  780.     /self.t := table()
  781.     /key := x
  782.     if / (self.t[key]) := x then return
  783.   end
  784. procedure Tablelookup(self,key)
  785. #line 604 "idol.iol"
  786.     if t := \self.t then return t[key]
  787.     return
  788.   end
  789. procedure Tableforeach(self)
  790. #line 608 "idol.iol"
  791.     if t := \self.t then every suspend !self.t
  792.   end
  793. record Table_state(__state,__methods,t)
  794. record Table_methods(size,insert,lookup,foreach)
  795. global Table__oprec
  796. procedure Table(t)
  797. local self,clone
  798. initial {
  799.   if /Table__oprec then Tableinitialize()
  800.   }
  801.   self := Table_state(&null,Table__oprec,t)
  802.   self.__state := self
  803.   return idol_object(self,Table__oprec)
  804. end
  805.  
  806. procedure Tableinitialize()
  807.   initial Table__oprec := Table_methods(Tablesize,Tableinsert,Tablelookup,Tableforeach)
  808. end
  809. procedure taqueinsert(self,x,key)
  810. #line 619 "idol.iol"
  811.     /self.l := []
  812.     if (__self1 := self).__methods.Table.insert(__self1.__state,x,key) then put(self.l,x)
  813.   end
  814. procedure taqueforeach(self)
  815. #line 623 "idol.iol"
  816.     if l := \self.l then every suspend !self.l
  817.   end
  818. procedure taqueinsert_t(self,x,key)
  819. #line 626 "idol.iol"
  820.     (__self1 := self).__methods.Table.insert(__self1.__state,x,key)
  821.   end
  822. procedure taqueforeach_t(self)
  823. #line 629 "idol.iol"
  824.     suspend (__self1 := self).__methods.Table.foreach(__self1.__state)
  825.   end
  826. record taque_state(__state,__methods,l,t)
  827. record taque_methods(insert,foreach,insert_t,foreach_t,size,lookup,Table)
  828. global taque__oprec, Table__oprec
  829. procedure taque(l,t)
  830. local self,clone
  831. initial {
  832.   if /taque__oprec then taqueinitialize()
  833.   if /Table__oprec then Tableinitialize()
  834.   taque__oprec.Table := Table__oprec
  835.   }
  836.   self := taque_state(&null,taque__oprec,l,t)
  837.   self.__state := self
  838.   return idol_object(self,taque__oprec)
  839. end
  840.  
  841. procedure taqueinitialize()
  842.   initial taque__oprec := taque_methods(taqueinsert,taqueforeach,taqueinsert_t,taqueforeach_t,Tablesize,Tablelookup)
  843. end
  844. procedure idTaqueparse(self,s)
  845. #line 639 "idol.iol"
  846.     s ? {
  847.       tab(many(white))
  848.       while name := tab(find(self.punc)) do {
  849.     (__self1 := self).__methods.insert(__self1.__state,trim(name))
  850.     move(1)
  851.     tab(many(white))
  852.       }
  853.       if any(nonwhite) then (__self1 := self).__methods.insert(__self1.__state,trim(tab(0)))
  854.     }
  855.     return
  856.   end
  857. procedure idTaqueString(self)
  858. #line 651 "idol.iol"
  859.     if /self.l then return ""
  860.     out := ""
  861.     every id := !self.l do out ||:= id||self.punc
  862.     return out[1:-1]
  863.   end
  864. record idTaque_state(__state,__methods,punc,l,t)
  865. record idTaque_methods(parse,String,insert,foreach,insert_t,foreach_t,size,lookup,taque,Table)
  866. global idTaque__oprec, taque__oprec, Table__oprec
  867. procedure idTaque(punc,l,t)
  868. local self,clone
  869. initial {
  870.   if /idTaque__oprec then idTaqueinitialize()
  871.   if /taque__oprec then taqueinitialize()
  872.   idTaque__oprec.taque := taque__oprec
  873.   if /Table__oprec then Tableinitialize()
  874.   idTaque__oprec.Table := Table__oprec
  875.   }
  876.   self := idTaque_state(&null,idTaque__oprec,punc,l,t)
  877.   self.__state := self
  878.   return idol_object(self,idTaque__oprec)
  879. end
  880.  
  881. procedure idTaqueinitialize()
  882.   initial idTaque__oprec := idTaque_methods(idTaqueparse,idTaqueString,taqueinsert,taqueforeach,taqueinsert_t,taqueforeach_t,Tablesize,Tablelookup)
  883. end
  884. procedure argListinsert(self,s)
  885. #line 663 "idol.iol"
  886.     if \self.varg then halt("variable arg must be final")
  887.     if i := find("[",s) then {
  888.       if not (j := find("]",s)) then halt("variable arg expected ]")
  889.       s[i : j+1] := ""
  890.       self.varg := s := trim(s)
  891.     }
  892.     (__self1 := self).__methods.idTaque.insert(__self1.__state,s)
  893.   end
  894. procedure argListString(self)
  895. #line 672 "idol.iol"
  896.     return (__self1 := self).__methods.idTaque.String(__self1.__state) || ((\self.varg & "[]") | "")
  897.   end
  898. record argList_state(__state,__methods,varg,punc,l,t)
  899. record argList_methods(insert,String,varg,parse,foreach,insert_t,foreach_t,size,lookup,idTaque,taque,Table)
  900. global argList__oprec, idTaque__oprec, taque__oprec, Table__oprec
  901. procedure argList(varg,punc,l,t)
  902. local self,clone
  903. initial {
  904.   if /argList__oprec then argListinitialize()
  905.   if /idTaque__oprec then idTaqueinitialize()
  906.   argList__oprec.idTaque := idTaque__oprec
  907.   if /taque__oprec then taqueinitialize()
  908.   argList__oprec.taque := taque__oprec
  909.   if /Table__oprec then Tableinitialize()
  910.   argList__oprec.Table := Table__oprec
  911.   }
  912.   self := argList_state(&null,argList__oprec,varg,punc,l,t)
  913.   self.__state := self
  914.   argListinitially(self)
  915.   return idol_object(self,argList__oprec)
  916. end
  917.  
  918. procedure argListinitialize()
  919.   initial argList__oprec := argList_methods(argListinsert,argListString,argListvarg,idTaqueparse,taqueforeach,taqueinsert_t,taqueforeach_t,Tablesize,Tablelookup)
  920. end
  921. procedure argListinitially(self)
  922. #line 675 "idol.iol"
  923.   self.punc := ","
  924. end
  925. procedure argListvarg(self)
  926.   return .(self.varg)
  927. end
  928.  
  929. procedure classFieldsString(self,s)
  930. #line 683 "idol.iol"
  931.     if *(rv := (__self1 := self).__methods.argList.String(__self1.__state)) = 0 then return ""
  932.     if /s | (s ~== "class") then return rv
  933.     if (__self1 := self).__methods.ispublic(__self1.__state,self.l[1]) then rv := "public "||rv
  934.     every field:=(__self1 := self).__methods.foreachpublic(__self1.__state) do rv[find(","||field,rv)] ||:= "public "
  935.     return rv
  936.   end
  937. procedure classFieldsforeachpublic(self)
  938. #line 690 "idol.iol"
  939.     if \self.publics then every suspend !self.publics
  940.   end
  941. procedure classFieldsispublic(self,s)
  942. #line 693 "idol.iol"
  943.     if \self.publics then every suspend !self.publics == s
  944.   end
  945. procedure classFieldsinsert(self,s)
  946. #line 696 "idol.iol"
  947.     s ? {
  948.       if ="public" & tab(many(white)) then {
  949.     s := tab(0)
  950.     /self.publics := []
  951.     put(self.publics,s)
  952.       }
  953.     }
  954.     (__self1 := self).__methods.argList.insert(__self1.__state,s)
  955.   end
  956. record classFields_state(__state,__methods,publics,varg,punc,l,t)
  957. record classFields_methods(String,foreachpublic,ispublic,insert,varg,parse,foreach,insert_t,foreach_t,size,lookup,argList,idTaque,taque,Table)
  958. global classFields__oprec, argList__oprec, idTaque__oprec, taque__oprec, Table__oprec
  959. procedure classFields(publics,varg,punc,l,t)
  960. local self,clone
  961. initial {
  962.   if /classFields__oprec then classFieldsinitialize()
  963.   if /argList__oprec then argListinitialize()
  964.   classFields__oprec.argList := argList__oprec
  965.   if /idTaque__oprec then idTaqueinitialize()
  966.   classFields__oprec.idTaque := idTaque__oprec
  967.   if /taque__oprec then taqueinitialize()
  968.   classFields__oprec.taque := taque__oprec
  969.   if /Table__oprec then Tableinitialize()
  970.   classFields__oprec.Table := Table__oprec
  971.   }
  972.   self := classFields_state(&null,classFields__oprec,publics,varg,punc,l,t)
  973.   self.__state := self
  974.   classFieldsinitially(self)
  975.   clone := classFields_state()
  976.   clone.__state := clone
  977.   clone.__methods := classFields__oprec
  978.   # inherited initialization from class argList
  979.     every i := 2 to *self do clone[i] := self[i]
  980.     argListinitially(clone)
  981.     self.varg := clone.varg
  982.   return idol_object(self,classFields__oprec)
  983. end
  984.  
  985. procedure classFieldsinitialize()
  986.   initial classFields__oprec := classFields_methods(classFieldsString,classFieldsforeachpublic,classFieldsispublic,classFieldsinsert,argListvarg,idTaqueparse,taqueforeach,taqueinsert_t,taqueforeach_t,Tablesize,Tablelookup)
  987. end
  988. procedure classFieldsinitially(self)
  989. #line 706 "idol.iol"
  990.   self.punc := ","
  991. end
  992.